// Validate that the specified runtime is valid (present in all tests)
const runtime: string = process.env.RUNTIME || 'nodejs18x';

if (!isValidRuntimeKey(runtime)) {
  throw new Error(`Invalid runtime key value: ${runtime}`);
}

// Generate an unique name for the test stack (this allows to run multiple e2e tests at the same time)
const uuid = v4();
const stackName = generateUniqueName(
  RESOURCE_NAME_PREFIX,
  uuid,
  runtime,
  'makeFnIdempotent'
);

// Specify the filename for the Lambda that will be deploy to run the test (this is unique to each test suite)
const makeHandlerIdempotentFile = 'makeHandlerIdempotent.test.FunctionCode.ts';

// Initialise resources to deploy & interact with the stack
const app = new App();
const ddb = new DynamoDBClient({});
const stack = new Stack(app, stackName);

/**
 * Add resources to the stack, in this case we are:
 * - specifying an unique name for the test case
 * - generating an unique name for the function (using the name from above)
 * - generating an unique name for the Dynamo DB Table (using the name from above)
 * - adding the CDK resources to the Stack (other file)
 *
 * NOTE: this is only for one test case
 */
const testDefault = 'default-sequential';
const functionNameDefault = generateUniqueName(
  RESOURCE_NAME_PREFIX,
  uuid,
  runtime,
  `${testDefault}-fn`
);
const ddbTableNameDefault = generateUniqueName(
  RESOURCE_NAME_PREFIX,
  uuid,
  runtime,
  `${testDefault}-table`
);
createIdempotencyResources(
  stack,
  runtime,
  ddbTableNameDefault,
  makeHandlerIdempotentFile,
  functionNameDefault,
  'handler'
);

// Doing the same as above, but for another test case (minimal differences)
const testDefaultParallel = 'default-parallel';
const functionNameDefaultParallel = generateUniqueName(
  RESOURCE_NAME_PREFIX,
  uuid,
  runtime,
  `${testDefaultParallel}-fn`
);
const ddbTableNameDefaultParallel = generateUniqueName(
  RESOURCE_NAME_PREFIX,
  uuid,
  runtime,
  `${testDefaultParallel}-table`
);
createIdempotencyResources(
  stack,
  runtime,
  ddbTableNameDefaultParallel,
  makeHandlerIdempotentFile,
  functionNameDefaultParallel,
  'handlerParallel'
);

// And again
const testTimeout = 'timeout';
const functionNameTimeout = generateUniqueName(
  RESOURCE_NAME_PREFIX,
  uuid,
  runtime,
  `${testTimeout}-fn`
);
const ddbTableNameTimeout = generateUniqueName(
  RESOURCE_NAME_PREFIX,
  uuid,
  runtime,
  `${testTimeout}-table`
);
createIdempotencyResources(
  stack,
  runtime,
  ddbTableNameTimeout,
  makeHandlerIdempotentFile,
  functionNameTimeout,
  'handlerTimeout',
  undefined,
  2
);

// And again..
const testExpired = 'expired';
const functionNameExpired = generateUniqueName(
  RESOURCE_NAME_PREFIX,
  uuid,
  runtime,
  `${testExpired}-fn`
);
const ddbTableNameExpired = generateUniqueName(
  RESOURCE_NAME_PREFIX,
  uuid,
  runtime,
  `${testExpired}-table`
);
createIdempotencyResources(
  stack,
  runtime,
  ddbTableNameExpired,
  makeHandlerIdempotentFile,
  functionNameExpired,
  'handlerExpired',
  undefined,
  2
);

beforeAll(async () => {
    await deployStack(app, stack);
  }, SETUP_TIMEOUT);

// Import the new class
import { TestStack } from '../../../testing';

// Initialize the the AWS SDK client(s) to interact with the deployed stack
const ddb = new DynamoDBClient({});

// Initialise the stack, passing a common resource prefix and test name,
// these will be used to generate unique names for each new resource
const stack = new TestStack(RESOURCE_NAME_PREFIX, 'makeHandlerIdempotent');
// Create the full path of the file that contains the Lambda fn (this has to be done here because it's relative to the test file)
const functionFileName = join(
  __dirname,
  'makeHandlerIdempotent.test.FunctionCode.ts'
);

beforeAll(async () => {
  /**
   * For each new case, define:
   * - a name for the test
   * - a function (that can be fully customised - see types in the PR diff)
   * - other resources (in this case a DynamoDB table)
  */
  stack.addTestCase({
    testCaseName: "default",
    function: {
      functionCode: {
        path: functionFileName,
        handler: "handler",
      },
    },
    dynamodb: {
      envVariableName: "IDEMPOTENCY_TABLE_NAME",
    },
  });

  // Do this of each test case
  stack.addTestCase({
    testCaseName: "default-parallel",
    function: {
      functionCode: {
        path: functionFileName,
        handler: "handlerParallel",
      },
    },
    dynamodb: {
      envVariableName: "IDEMPOTENCY_TABLE_NAME",
    },
  });

  stack.addTestCase({
    testCaseName: "timeout",
    function: {
      functionCode: {
        path: functionFileName,
        handler: "handlerTimeout",
      },
      functionConfigs: {
        timeout: 2,
      },
    },
    dynamodb: {
      envVariableName: "IDEMPOTENCY_TABLE_NAME",
    },
  });

  stack.addTestCase({
    testCaseName: "expired",
    function: {
      functionCode: {
        path: functionFileName,
        handler: "handlerExpired",
      },
      functionConfigs: {
        timeout: 2,
      },
    },
    dynamodb: {
      envVariableName: "IDEMPOTENCY_TABLE_NAME",
    },
  });

  await stack.deploy();
}, SETUP_TIMEOUT);

const testCase = stack.getTestCase('default');
const logs = await testCase.invokeFunctionSequentially({ // returns the Cw logs of those 3 invocations
  payload: { ... },
  number: 3,
});

const testCase = stack.getTestCase('default');
await testCase.invokeFunctionInParallel({
  payload: { ... },
  number: 3
});
const traces = await testCase.getTraces(); // retrieves all the traces of those 3 invocations